// 基础版本的单例模式实现
#include <memory>
#include <mutex>
#include <iostream>
class Singleton
{
public:
    // 删除拷贝构造函数和赋值运算符
    Singleton(const Singleton &) = delete;
    Singleton &operator=(const Singleton &) = delete;

    // 获取单例实例的静态方法
    static Singleton &GetInstance()
    {
        static Singleton instance; // C++11保证线程安全的初始化
        return instance;
    }

private:
    // 私有构造函数
    Singleton() = default;
    // 私有析构函数
    ~Singleton() = default;
};
// 单例模式模板类
// 单例模式模板类实现
template <typename T>
class Singleton_t
{
public:
    // 删除拷贝构造函数和赋值运算符
    Singleton_t(const Singleton_t &) = delete;
    Singleton_t &operator=(const Singleton_t &) = delete;

    // 获取单例实例的静态方法
    static T &GetInstance()
    {
        static T instance; // C++11保证线程安全的初始化
        return instance;
    }

protected:
    // protected构造函数，允许继承
    Singleton_t() = default;
    // protected析构函数
    ~Singleton_t() = default;
};

// 示例：使用模板单例类
class MyClass : public Singleton_t<MyClass>
{
    // 友元声明，允许基类访问构造函数
    friend class Singleton_t<MyClass>;

private:
    MyClass() = default; // 私有构造函数
public:
    void Print() { std::cout << "MyClass singleton instance" << std::endl; }
};
int main()
{
    // 获取单例实例
    Singleton &instance = Singleton::GetInstance();
    Singleton &instance2 = Singleton::GetInstance();

    // 打印单例实例的地址
    std::cout << "Singleton instance address: " << &instance << std::endl;
    std::cout << "Singleton instance address: " << &instance2 << std::endl;

    // 分割线
    std::cout << "----------------------------------------" << std::endl;

    // 获取模板单例实例
    MyClass &myClassInstance = MyClass::GetInstance();
    MyClass &myClassInstance2 = MyClass::GetInstance();
    myClassInstance.Print();

    // 打印模板单例实例的地址
    std::cout << "MyClass instance address: " << &myClassInstance << std::endl;
    std::cout << "MyClass instance address: " << &myClassInstance2 << std::endl;

    return 0;
}
